import { _decorator, Vec3 , Node} from 'cc';
import { SkillManager } from './SkillManager';
import { EBuff, EGroup, EntityType, ESkill } from '../Config/Enum';
import ObjectPoolManager from '../Core/ObjectPoolManager';
import { Collider2D } from 'cc';
import { PlayerManager } from '../PlayerManager';
import { buffConfig, SkillConfig } from '../Config/SkillConfig';
import { EnemyManager } from '../EnemyManager';
import { BattleManager } from '../BattleManager';

const { ccclass } = _decorator;
// 武学一：金顶佛光 峨眉掌法，三次冰锥跟踪攻击 

// 符文1 - 透骨寒冰 20%概率无视防御
// 符文2 - 霜冻结界 冰锥减速50%
// 符文3 - 冰爆指劲 在附近3个敌人中间弹射


@ccclass('EmeiSkill1')
export class EmeiSkill1 extends SkillManager {
    private _hasSplit = false;
    private _contactPosition: Vec3 = new Vec3(0, 0, 0);
    runeId
    effectChance
    buffTypeList
    buffDuration
    

    // 新增标志：是否是主子弹（由玩家直接发射的子弹）
    private isMasterBullet = true;
    pm
    _originalDirection: Vec3;
    enemyDirection: Vec3;

    init(type: ESkill, pm: PlayerManager) {
        // 重置所有状态
        this.pm = pm;
        //this.reset();
        super.init(type, pm);

        
        // 只有主子弹需要重置分裂标志
        if (this.isMasterBullet) {
            this._hasSplit = false;
        }


        // 分裂成3个冰锥，中间这根保持原来的direction，左右两根分别偏移30度飞行1秒然后飞向direction
        if (!this._hasSplit) {
            this.splitIntoThreeBullets();
            // this._hasSplit = true; // 标记为已分裂
            // ObjectPoolManager.Instance.ret(this.node); // 立即回收主子弹
        }



        // 其他符文效果
        switch (this.runeId) {
            case 1:
                break;
            case 2:
                break;  
            case 3:
                break;
            default:
                //console.warn(`未知符文ID: ${this.runeId}`);
                break;
        }
    }

    protected onHitEnemy(self, other: Collider2D): void {
        this.em = other.node.getComponent(EnemyManager)        
        switch (this.runeId) {
            case 1: //透骨寒冰 20%概率无视防御
                if (Math.random() < 0.2) {
                    this.isIngoreDp = true
                }
                break;
            case 2:
                // 霜冻结界 20%几率冰锥减速50%

                this.applyBuffToEnemy(this.em,0.2, EBuff.Slow, 0.5, 3); // 减速50%，持续3秒
                break;
            case 3: //符文3 - 冰爆指劲 在附近3个敌人中间弹射todo
            //敌人生命多于75%则一定会心一击
                

                
                if(this.em.hp>this.em.maxHp*0.5)this.isCritical=true
                
                break;
            default:
                break;
        }

        super.onHitEnemy(self, other,this.isCritical);

    }


    
    /**
     * 分裂成三个冰锥
     */
    private splitIntoThreeBullets() {
        // 保存原始方向
        const originalDir = this.direction.clone();
        
        // 创建中间子弹（保持原方向）
        this.createSplitBullet(originalDir, false);
        
        // 创建左侧子弹（偏移20度）
        const leftDir = this.calculateOffsetDirection(originalDir, 20);
        this.createSplitBullet(leftDir, true);
        
        // 创建右侧子弹（偏移-20度）
        const rightDir = this.calculateOffsetDirection(originalDir, -20);
        this.createSplitBullet(rightDir, true);
        
        // 回收主子弹
        ObjectPoolManager.Instance.ret(this.node);
    }

    /**
     * 创建分裂子弹
     * @param initialDir 子弹初始方向
     * @param needTurn 1秒后是否需要转向原始方向
     */
    /**
     * 创建分裂子弹
     * @param initialDir 子弹初始方向
     * @param needTurn 1秒后是否需要转向原始方向
     */
    private createSplitBullet(initialDir: Vec3, needTurn: boolean) {
        const bulletNode = ObjectPoolManager.Instance.get(this.type as EntityType);
        bulletNode.setWorldPosition(this.node.worldPosition);
        
        const bullet = bulletNode.getComponent(EmeiSkill1);
        if (!bullet) return;
        
        // 设置分裂子弹属性
        bullet.isMasterBullet = false;
        bullet._hasSplit = true;
        
        // 初始化子弹
        bullet.init(this.type, this.pm);
        bullet.setDirection(initialDir);
        
        // 如果需要转向，设置0.5秒后转向最近的敌人
        if (needTurn) {
            bullet.scheduleOnce(() => {
                // 关键修改：每次转向时重新计算最近的敌人方向
                const nearestEnemy = BattleManager.Instance.nearestEnemy;
                if (!nearestEnemy) return;

                    const enemyPos = nearestEnemy.worldPosition;
                    const bulletPos = bullet.node.worldPosition;
                    
                    // 创建新的方向向量
                    const newDirection = new Vec3();
                    Vec3.subtract(newDirection, enemyPos, bulletPos);
                    newDirection.normalize();
                    
                    bullet.setDirection(newDirection);
                
            }, 0.3);
        }
    }

    /**
     * 计算偏移方向
     * @param baseDir 基础方向
     * @param angle 偏移角度（度）
     */
    private calculateOffsetDirection(baseDir: Vec3, angle: number): Vec3 {
        const rad = angle * Math.PI / 180;
        const cos = Math.cos(rad);
        const sin = Math.sin(rad);
        
        // 创建旋转后的方向向量
        return new Vec3(
            baseDir.x * cos - baseDir.y * sin,
            baseDir.x * sin + baseDir.y * cos,
            0
        ).normalize();
    }




}